package com.tuling.sentinelview.controller;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.EntryType;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.Tracer;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.tuling.sentinelview.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @description: TODO
 * @Author li
 * @Date 2025/4/23 15:59
 */
@RestController
@Slf4j
public class HelloController {
    private static final String RESOURCE_NAME = "hello";
    private static final String USER_RESOURCE_NAME = "user";
    private static final String DEGRADE_RESOURCE_NAME = "degrade";

    // 方式一：进行sentinel流控
    @RequestMapping(value = "/hello")
    public String hello() {
        Entry entry = null;
        try {
            // sentinel针对资源进行限制的
            entry = SphU.entry(RESOURCE_NAME);
            // 被保护的业务逻辑
            String str = "hello world";
            log.info("====" + str + "====");
            return str;
        } catch (BlockException e1) {
            // 资源访问组织，被限流或被降级
            // 进行相应的处理操作
            log.info("block!");
            return "被流控了";
        } catch (Exception ex) {
            // 若需要配置降级规则，需要通过这种方式记录业务异常
            Tracer.traceEntry(ex, entry);
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
        return null;
    }

    /**
     * 定义规则
     * spring 的初始化方法
     * 初始化流控规则
     */
    @PostConstruct
    private static void initFlowRules() {
        // 流控规则
        List<FlowRule> rules = new ArrayList<>();
        // 流控
        FlowRule rule = new FlowRule();
        // 设置受保护的资源，为哪个资源进行流控
        rule.setResource(RESOURCE_NAME);
        // 设置流控规则QPS
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // 设置受保护的资源阈值，set limit QPS to 20
        rule.setCount(1);
        rules.add(rule);

        FlowRule rule2 = new FlowRule();
        rule2.setResource(USER_RESOURCE_NAME);
        rule2.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule2.setCount(1);
        rules.add(rule2);

        // 加载配置好的规则
        FlowRuleManager.loadRules(rules);
    }

    /**
     * 方式二
     * @SentinelResource 改善接口中资源定义和被流控降级后的处理方法
     * 怎么使用：
     * 1、添加sentinel-annotation-aspectj依赖
     * 2、配置bean：SentinelResourceAspect
     * value    定义资源
     * blockHandler     设置被流控降级后的处理方法，默认该方法必须声明在同一个类中
     * 如果不想同一个类里面，可以设置blockHandlerClass，但是方法要加上static
     * fallback     当接口出现异常，就可以交给fallback指定的方法进行处理，默认该方法必须声明在同一个类中，
     * 如果不想同一个类里面，可以设置fallbackClass，但是方法要加上static
     * blockHandler和fallback同时被指定了，则blockHandler优先级更高
     * exceptionsToIgnore   排除哪些异常不处理
     */
    @RequestMapping("/user")
    @SentinelResource(value = USER_RESOURCE_NAME,
            blockHandler = "blockHandlerForGetUser",
            fallback = "fallbackHandlerForGetUser",
            exceptionsToIgnore = {ArithmeticException.class})
    public User getUser(String username) {
        int a = 1 / 0;
        return new User(username);
    }

    /**
     * 注意：
     * 1、一定要是public
     * 2、返回值一定要和源方法保证一致，包含源方法的参数
     * 3、可以在参数最后添加BlockException，可以区分是什么规则的处理方法
     */
    public User blockHandlerForGetUser(String id, BlockException ex) {
        log.error(ex.getMessage());
        return new User("流控！！" + id);
    }

    public User fallbackHandlerForGetUser(String id, Throwable e) {
        return new User(e.getMessage());
    }

    /**
     * 初始化降级规则
     */
    @PostConstruct
    public void initDegradeRule() {
        List<DegradeRule> degradeRules = new ArrayList<>();
        DegradeRule degradeRule = new DegradeRule();
        degradeRule.setResource(DEGRADE_RESOURCE_NAME);
        // 设置规则策略：异常数
        degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
        // 触发熔断异常数
        degradeRule.setCount(2);
        // 触发熔断的最小请求数
        degradeRule.setMinRequestAmount(2);
        // 统计时长，单位ms，60s内触发两次异常就熔断，时间太短不好测
        degradeRule.setStatIntervalMs(60*1000*60);
        // 熔断持续时长，单位s，降级策略独有，一旦触发熔断，在这个时间内的对应请求都会触发降级方法，
        // 10s后，进入半开状态恢复接口请求调用，如果第一次请求就异常，不会根据设置的时长进行熔断，而会直接熔断
        degradeRule.setTimeWindow(10);

        degradeRules.add(degradeRule);
        DegradeRuleManager.loadRules(degradeRules);
    }

    @RequestMapping("/degrade")
    @SentinelResource(value = DEGRADE_RESOURCE_NAME, entryType = EntryType.IN, blockHandler = "blockHandlerForFb")
    public User degrade(String id) throws InterruptedException {
        // 异常数/比例
        throw new RuntimeException("异常");

        // 慢调用比例
        /*TimeUnit.SECONDS.sleep(1);
        return new User("正常" + id);*/
    }

    public User blockHandlerForFb(String id, BlockException ex) {
        return new User("熔断降级");
    }
}
